package concurrency;//: concurrency/ExchangerDemo.java

import net.mindview.util.BasicGenerator;
import net.mindview.util.Generator;

import java.util.List;
import java.util.concurrent.*;

class ExchangerProducer<T> implements Runnable {
  private Generator<T> generator;
  private Exchanger<List<T>> exchanger;
  private List<T> holder;

  ExchangerProducer(Exchanger<List<T>> exchg, Generator<T> gen, List<T> holder) {
    exchanger = exchg;
    generator = gen;
    this.holder = holder;
  }

  public void run() {
    try {
      while (!Thread.interrupted()) {
        for (int i = 0; i < ExchangerDemo.size; i++)
          holder.add(generator.next());
        // Exchange full for empty:
        System.out.println("1.ExchangerProducer:" + holder.toString());
        holder = exchanger.exchange(holder);
        System.out.println("2.ExchangerProducer:" + holder.toString());
      }
    } catch (InterruptedException e) {
      // OK to terminate this way.
    }
  }
}

class ExchangerConsumer<T> implements Runnable {
  private Exchanger<List<T>> exchanger;
  private List<T> holder;
  private volatile T value;

  ExchangerConsumer(Exchanger<List<T>> ex, List<T> holder) {
    exchanger = ex;
    this.holder = holder;
  }

  public void run() {
    try {
      while (!Thread.interrupted()) {
        TimeUnit.MILLISECONDS.sleep(100);
        System.out.println("1.ExchangerConsumer:" + holder.toString());
        holder = exchanger.exchange(holder);
        System.out.println("2.ExchangerConsumer:" + holder.toString());
        for (T x : holder) {
          value = x; // Fetch out value
          holder.remove(x); // OK for CopyOnWriteArrayList
        }
      }
    } catch (InterruptedException e) {
      // OK to terminate this way.
    }
    System.out.println("Final value: " + value);
  }
}

public class ExchangerDemo {
  static int size = 10;
  static int delay = 1; // Seconds

  public static void main(String[] args) throws Exception {
    if (args.length > 0)
      size = new Integer(args[0]);
    if (args.length > 1)
      delay = new Integer(args[1]);

    ExecutorService exec = Executors.newCachedThreadPool();
    Exchanger<List<Fat>> xc = new Exchanger<List<Fat>>();

    List<Fat>
        producerList = new CopyOnWriteArrayList<Fat>(),
        consumerList = new CopyOnWriteArrayList<Fat>();

    exec.execute(new ExchangerProducer<Fat>(xc, BasicGenerator.create(Fat.class), producerList));
    exec.execute(new ExchangerConsumer<Fat>(xc, consumerList));

    TimeUnit.SECONDS.sleep(delay);
    exec.shutdownNow();
  }
} /* Output: (Sample)
Final value: Fat id: 29999
*///:~
